
circure_queue:     file format elf32-littlearm


Disassembly of section .init:

000103cc <_init>:
   103cc:	e1a0c00d 	mov	ip, sp
   103d0:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   103d4:	e24cb004 	sub	fp, ip, #4
   103d8:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}

Disassembly of section .plt:

000103dc <printf@plt-0x14>:
   103dc:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
   103e0:	e59fe004 	ldr	lr, [pc, #4]	; 103ec <_init+0x20>
   103e4:	e08fe00e 	add	lr, pc, lr
   103e8:	e5bef008 	ldr	pc, [lr, #8]!
   103ec:	00010cd8 	.word	0x00010cd8

000103f0 <printf@plt>:
   103f0:	e28fc600 	add	ip, pc, #0, 12
   103f4:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103f8:	e5bcfcd8 	ldr	pc, [ip, #3288]!	; 0xcd8

000103fc <puts@plt>:
   103fc:	e28fc600 	add	ip, pc, #0, 12
   10400:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10404:	e5bcfcd0 	ldr	pc, [ip, #3280]!	; 0xcd0

00010408 <malloc@plt>:
   10408:	e28fc600 	add	ip, pc, #0, 12
   1040c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10410:	e5bcfcc8 	ldr	pc, [ip, #3272]!	; 0xcc8

00010414 <abort@plt>:
   10414:	e28fc600 	add	ip, pc, #0, 12
   10418:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1041c:	e5bcfcc0 	ldr	pc, [ip, #3264]!	; 0xcc0

00010420 <__deregister_frame_info@plt>:
   10420:	e28fc600 	add	ip, pc, #0, 12
   10424:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10428:	e5bcfcb8 	ldr	pc, [ip, #3256]!	; 0xcb8

0001042c <__uClibc_main@plt>:
   1042c:	e28fc600 	add	ip, pc, #0, 12
   10430:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10434:	e5bcfcb0 	ldr	pc, [ip, #3248]!	; 0xcb0

00010438 <exit@plt>:
   10438:	e28fc600 	add	ip, pc, #0, 12
   1043c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10440:	e5bcfca8 	ldr	pc, [ip, #3240]!	; 0xca8

00010444 <__register_frame_info@plt>:
   10444:	e28fc600 	add	ip, pc, #0, 12
   10448:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1044c:	e5bcfca0 	ldr	pc, [ip, #3232]!	; 0xca0

00010450 <raise@plt>:
   10450:	e28fc600 	add	ip, pc, #0, 12
   10454:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10458:	e5bcfc98 	ldr	pc, [ip, #3224]!	; 0xc98

0001045c <free@plt>:
   1045c:	e28fc600 	add	ip, pc, #0, 12
   10460:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10464:	e5bcfc90 	ldr	pc, [ip, #3216]!	; 0xc90

Disassembly of section .text:

00010468 <_start>:
   10468:	e3a0b000 	.word	0xe3a0b000
   1046c:	e3a0e000 	.word	0xe3a0e000
   10470:	e49d1004 	.word	0xe49d1004
   10474:	e1a0200d 	.word	0xe1a0200d
   10478:	e52d2004 	.word	0xe52d2004
   1047c:	e52d0004 	.word	0xe52d0004
   10480:	e59fc010 	.word	0xe59fc010
   10484:	e52dc004 	.word	0xe52dc004
   10488:	e59f000c 	.word	0xe59f000c
   1048c:	e59f300c 	.word	0xe59f300c
   10490:	eaffffe5 	.word	0xeaffffe5
   10494:	ebffffde 	.word	0xebffffde
   10498:	00010f38 	.word	0x00010f38
   1049c:	00010964 	.word	0x00010964
   104a0:	000103cc 	.word	0x000103cc

000104a4 <deregister_tm_clones>:
   104a4:	e59f301c 	ldr	r3, [pc, #28]	; 104c8 <deregister_tm_clones+0x24>
   104a8:	e59f001c 	ldr	r0, [pc, #28]	; 104cc <deregister_tm_clones+0x28>
   104ac:	e0603003 	rsb	r3, r0, r3
   104b0:	e3530006 	cmp	r3, #6
   104b4:	912fff1e 	bxls	lr
   104b8:	e59f3010 	ldr	r3, [pc, #16]	; 104d0 <deregister_tm_clones+0x2c>
   104bc:	e3530000 	cmp	r3, #0
   104c0:	012fff1e 	bxeq	lr
   104c4:	e12fff13 	bx	r3
   104c8:	00021103 	.word	0x00021103
   104cc:	00021100 	.word	0x00021100
   104d0:	00000000 	.word	0x00000000

000104d4 <register_tm_clones>:
   104d4:	e59f1024 	ldr	r1, [pc, #36]	; 10500 <register_tm_clones+0x2c>
   104d8:	e59f0024 	ldr	r0, [pc, #36]	; 10504 <register_tm_clones+0x30>
   104dc:	e0601001 	rsb	r1, r0, r1
   104e0:	e1a01141 	asr	r1, r1, #2
   104e4:	e0811fa1 	add	r1, r1, r1, lsr #31
   104e8:	e1b010c1 	asrs	r1, r1, #1
   104ec:	012fff1e 	bxeq	lr
   104f0:	e59f3010 	ldr	r3, [pc, #16]	; 10508 <register_tm_clones+0x34>
   104f4:	e3530000 	cmp	r3, #0
   104f8:	012fff1e 	bxeq	lr
   104fc:	e12fff13 	bx	r3
   10500:	00021100 	.word	0x00021100
   10504:	00021100 	.word	0x00021100
   10508:	00000000 	.word	0x00000000

0001050c <__do_global_dtors_aux>:
   1050c:	e92d4010 	push	{r4, lr}
   10510:	e59f402c 	ldr	r4, [pc, #44]	; 10544 <__do_global_dtors_aux+0x38>
   10514:	e5d43000 	ldrb	r3, [r4]
   10518:	e3530000 	cmp	r3, #0
   1051c:	18bd8010 	popne	{r4, pc}
   10520:	ebffffdf 	bl	104a4 <deregister_tm_clones>
   10524:	e59f301c 	ldr	r3, [pc, #28]	; 10548 <__do_global_dtors_aux+0x3c>
   10528:	e3530000 	cmp	r3, #0
   1052c:	0a000001 	beq	10538 <__do_global_dtors_aux+0x2c>
   10530:	e59f0014 	ldr	r0, [pc, #20]	; 1054c <__do_global_dtors_aux+0x40>
   10534:	ebffffb9 	bl	10420 <__deregister_frame_info@plt>
   10538:	e3a03001 	mov	r3, #1
   1053c:	e5c43000 	strb	r3, [r4]
   10540:	e8bd8010 	pop	{r4, pc}
   10544:	00021100 	.word	0x00021100
   10548:	00000000 	.word	0x00000000
   1054c:	00010fa4 	.word	0x00010fa4

00010550 <frame_dummy>:
   10550:	e59f3040 	ldr	r3, [pc, #64]	; 10598 <frame_dummy+0x48>
   10554:	e92d4010 	push	{r4, lr}
   10558:	e3530000 	cmp	r3, #0
   1055c:	0a000002 	beq	1056c <frame_dummy+0x1c>
   10560:	e59f1034 	ldr	r1, [pc, #52]	; 1059c <frame_dummy+0x4c>
   10564:	e59f0034 	ldr	r0, [pc, #52]	; 105a0 <frame_dummy+0x50>
   10568:	ebffffb5 	bl	10444 <__register_frame_info@plt>
   1056c:	e59f0030 	ldr	r0, [pc, #48]	; 105a4 <frame_dummy+0x54>
   10570:	e5903000 	ldr	r3, [r0]
   10574:	e3530000 	cmp	r3, #0
   10578:	1a000001 	bne	10584 <frame_dummy+0x34>
   1057c:	e8bd4010 	pop	{r4, lr}
   10580:	eaffffd3 	b	104d4 <register_tm_clones>
   10584:	e59f301c 	ldr	r3, [pc, #28]	; 105a8 <frame_dummy+0x58>
   10588:	e3530000 	cmp	r3, #0
   1058c:	0afffffa 	beq	1057c <frame_dummy+0x2c>
   10590:	e12fff33 	blx	r3
   10594:	eafffff8 	b	1057c <frame_dummy+0x2c>
   10598:	00000000 	.word	0x00000000
   1059c:	00021104 	.word	0x00021104
   105a0:	00010fa4 	.word	0x00010fa4
   105a4:	00021008 	.word	0x00021008
   105a8:	00000000 	.word	0x00000000

000105ac <init>:
  int front, rear;
  int max_size;
};

void init(struct queue * src, int max)
{
   105ac:	e92d4800 	push	{fp, lr}
   105b0:	e28db004 	add	fp, sp, #4
   105b4:	e24dd008 	sub	sp, sp, #8
   105b8:	e50b0008 	str	r0, [fp, #-8] ; src
   105bc:	e50b100c 	str	r1, [fp, #-12]        ; max
  src->queue = (int *) malloc (sizeof(int) * max);
   105c0:	e51b300c 	ldr	r3, [fp, #-12]       ; max
   105c4:	e1a03103 	lsl	r3, r3, #2           ; max = max << 2   
   105c8:	e1a00003 	mov	r0, r3               ; 
   105cc:	ebffff8d 	bl	10408 <malloc@plt>
   105d0:	e1a03000 	mov	r3, r0 ; malloc return value
   105d4:	e1a02003 	mov	r2, r3 ; r2 = r3
   105d8:	e51b3008 	ldr	r3, [fp, #-8] ; src
   105dc:	e5832000 	str	r2, [r3]      ; src->queue = malloc
  if (!src->queue) {
   105e0:	e51b3008 	ldr	r3, [fp, #-8] ; src
   105e4:	e5933000 	ldr	r3, [r3]      ; src->queue
   105e8:	e3530000 	cmp	r3, #0
   105ec:	1a000003 	bne	10600 <init+0x54>
    printf("init malloc fail.\n");
   105f0:	e59f0038 	ldr	r0, [pc, #56]	; 10630 <init+0x84>
   105f4:	ebffff80 	bl	103fc <puts@plt>
    exit(0);
   105f8:	e3a00000 	mov	r0, #0
   105fc:	ebffff8d 	bl	10438 <exit@plt>
  }
  
  src->max_size = max;
   10600:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10604:	e51b200c 	ldr	r2, [fp, #-12] ; mxc
   10608:	e583200c 	str	r2, [r3, #12]  ; src->max_size
  src->front = src->rear = 0;
   1060c:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10610:	e3a02000 	mov	r2, #0
   10614:	e5832008 	str	r2, [r3, #8] ; src->rear = 0
   10618:	e51b3008 	ldr	r3, [fp, #-8] ; src
   1061c:	e5932008 	ldr	r2, [r3, #8]  ; src->rear
   10620:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10624:	e5832004 	str	r2, [r3, #4]  ; src->front=src->rear
}
   10628:	e24bd004 	sub	sp, fp, #4
   1062c:	e8bd8800 	pop	{fp, pc}
   10630:	00010f48 	.word	0x00010f48

00010634 <empty>:

int empty(struct queue * src)
{
   10634:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   10638:	e28db000 	add	fp, sp, #0
   1063c:	e24dd00c 	sub	sp, sp, #12
   10640:	e50b0008 	str	r0, [fp, #-8] ; src
  if (src->front == src->rear)
   10644:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10648:	e5932004 	ldr	r2, [r3, #4]  ; src->front
   1064c:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10650:	e5933008 	ldr	r3, [r3, #8]  ; src->rear
   10654:	e1520003 	cmp	r2, r3
   10658:	1a000001 	bne	10664 <empty+0x30>
    return 1;
   1065c:	e3a03001 	mov	r3, #1
   10660:	ea000000 	b	10668 <empty+0x34>
  else
    return 0;
   10664:	e3a03000 	mov	r3, #0
}
   10668:	e1a00003 	mov	r0, r3
   1066c:	e24bd000 	sub	sp, fp, #0
   10670:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   10674:	e12fff1e 	bx	lr

00010678 <full>:

int full(struct queue * src)
{
   10678:	e92d4810 	push	{r4, fp, lr}
   1067c:	e28db008 	add	fp, sp, #8
   10680:	e24dd00c 	sub	sp, sp, #12
   10684:	e50b0010 	str	r0, [fp, #-16] ; src
  if (src->front == (src->rear + 1) % src->max_size) // 判断循环链表是否满，留一个预留空间不用 
   10688:	e51b3010 	ldr	r3, [fp, #-16]           ; src
   1068c:	e5934004 	ldr	r4, [r3, #4]             ; src->front
   10690:	e51b3010 	ldr	r3, [fp, #-16]           ; src
   10694:	e5933008 	ldr	r3, [r3, #8]             ; src->rear
   10698:	e2832001 	add	r2, r3, #1     ; r2=src->rear+1
   1069c:	e51b3010 	ldr	r3, [fp, #-16] ; src
   106a0:	e593300c 	ldr	r3, [r3, #12]  ; src->max_size
   106a4:	e1a01003 	mov	r1, r3         ; r1 = src->max_size
   106a8:	e1a00002 	mov	r0, r2         ; r0 = src->rear+1 
   106ac:	eb000215 	bl	10f08 <__aeabi_idivmod>
   106b0:	e1a03001 	mov	r3, r1 ; src->max_size
   106b4:	e1540003 	cmp	r4, r3 ; r4 = src->max_size
   106b8:	1a000001 	bne	106c4 <full+0x4c>
    return 1;
   106bc:	e3a03001 	mov	r3, #1
   106c0:	ea000000 	b	106c8 <full+0x50>
  else
    return 0;
   106c4:	e3a03000 	mov	r3, #0
}
   106c8:	e1a00003 	mov	r0, r3
   106cc:	e24bd008 	sub	sp, fp, #8
   106d0:	e8bd8810 	pop	{r4, fp, pc}

000106d4 <enqueue>:

void enqueue(struct queue * src, int value)
{
   106d4:	e92d4800 	push	{fp, lr}
   106d8:	e28db004 	add	fp, sp, #4
   106dc:	e24dd008 	sub	sp, sp, #8
   106e0:	e50b0008 	str	r0, [fp, #-8] ; src
   106e4:	e50b100c 	str	r1, [fp, #-12] ; value
  if (full(src)) {
   106e8:	e51b0008 	ldr	r0, [fp, #-8] ; src
   106ec:	ebffffe1 	bl	10678 <full>
   106f0:	e1a03000 	mov	r3, r0 ; full return value
   106f4:	e3530000 	cmp	r3, #0
   106f8:	0a000002 	beq	10708 <enqueue+0x34>
    printf("queue was full.\n");
   106fc:	e59f005c 	ldr	r0, [pc, #92]	; 10760 <enqueue+0x8c>
   10700:	ebffff3d 	bl	103fc <puts@plt>
    return ;
   10704:	ea000013 	b	10758 <enqueue+0x84>
  }

  src->queue[src->rear] = value;
   10708:	e51b3008 	ldr	r3, [fp, #-8] ; src
   1070c:	e5932000 	ldr	r2, [r3]      ; src->queue
   10710:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10714:	e5933008 	ldr	r3, [r3, #8]  ; src->rear
   10718:	e1a03103 	lsl	r3, r3, #2    ; src->rear=src->rear<<2
   1071c:	e0823003 	add	r3, r2, r3    ; src->rear=src->rear<<2+src->queue
   10720:	e51b200c 	ldr	r2, [fp, #-12] ; value
   10724:	e5832000 	str	r2, [r3]       ; src->rear = value
  src->rear = (src->rear + 1) % src->max_size;  // 取余，当src->rear+1=max_size时，又转回到0.
   10728:	e51b3008 	ldr	r3, [fp, #-8]    ; src
   1072c:	e5933008 	ldr	r3, [r3, #8]     ; src->rear
   10730:	e2832001 	add	r2, r3, #1       ; r2 = src->rear+1
   10734:	e51b3008 	ldr	r3, [fp, #-8]    ; src
   10738:	e593300c 	ldr	r3, [r3, #12]    ; src->max_size
   1073c:	e1a01003 	mov	r1, r3           ; r1 = src->max_size
   10740:	e1a00002 	mov	r0, r2           ; r0 = src->rear+1
   10744:	eb0001ef 	bl	10f08 <__aeabi_idivmod>
   10748:	e1a03001 	mov	r3, r1 ; r3 = src->max_size
   1074c:	e1a02003 	mov	r2, r3 ; r2 = src->max_size
   10750:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10754:	e5832008 	str	r2, [r3, #8]  ; src->rear = src->max_size
}
   10758:	e24bd004 	sub	sp, fp, #4
   1075c:	e8bd8800 	pop	{fp, pc}
   10760:	00010f5c 	.word	0x00010f5c

00010764 <dequeue>:

void dequeue(struct queue * src)
{
   10764:	e92d4800 	push	{fp, lr}
   10768:	e28db004 	add	fp, sp, #4
   1076c:	e24dd008 	sub	sp, sp, #8
   10770:	e50b0008 	str	r0, [fp, #-8] ; src
  if (empty(src)) {
   10774:	e51b0008 	ldr	r0, [fp, #-8] ; src
   10778:	ebffffad 	bl	10634 <empty>
   1077c:	e1a03000 	mov	r3, r0
   10780:	e3530000 	cmp	r3, #0
   10784:	0a000002 	beq	10794 <dequeue+0x30>
    printf("queue is empty.\n");
   10788:	e59f005c 	ldr	r0, [pc, #92]	; 107ec <dequeue+0x88>
   1078c:	ebffff1a 	bl	103fc <puts@plt>
    return ;
   10790:	ea000013 	b	107e4 <dequeue+0x80>
  }
  
  src->queue[src->front] = -1;
   10794:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10798:	e5932000 	ldr	r2, [r3]      ; src->queue
   1079c:	e51b3008 	ldr	r3, [fp, #-8] ; src
   107a0:	e5933004 	ldr	r3, [r3, #4]  ; src->front
   107a4:	e1a03103 	lsl	r3, r3, #2    ; src->front=src->front<<2
   107a8:	e0823003 	add	r3, r2, r3    ; src->front=src->queue+src->front<<2
   107ac:	e3e02000 	mvn	r2, #0        ; qufan
   107b0:	e5832000 	str	r2, [r3]      ; src->front=~0
  src->front = (src->front + 1) % src->max_size;
   107b4:	e51b3008 	ldr	r3, [fp, #-8]      ; src
   107b8:	e5933004 	ldr	r3, [r3, #4]       ; src->front
   107bc:	e2832001 	add	r2, r3, #1         ; r2=src->front+1
   107c0:	e51b3008 	ldr	r3, [fp, #-8]      ; src
   107c4:	e593300c 	ldr	r3, [r3, #12]      ; src->max_size
   107c8:	e1a01003 	mov	r1, r3             ; r1=src->max_size
   107cc:	e1a00002 	mov	r0, r2             ; src->front+1
   107d0:	eb0001cc 	bl	10f08 <__aeabi_idivmod>
   107d4:	e1a03001 	mov	r3, r1 ; src->max_size
   107d8:	e1a02003 	mov	r2, r3 ; r2 = src->max_size
   107dc:	e51b3008 	ldr	r3, [fp, #-8] ; src
   107e0:	e5832004 	str	r2, [r3, #4]  ; src->front
  //src->front++;
}
   107e4:	e24bd004 	sub	sp, fp, #4
   107e8:	e8bd8800 	pop	{fp, pc}
   107ec:	00010f6c 	.word	0x00010f6c

000107f0 <display>:

void display(struct queue * src)
{
   107f0:	e92d4800 	push	{fp, lr}
   107f4:	e28db004 	add	fp, sp, #4
   107f8:	e24dd010 	sub	sp, sp, #16
   107fc:	e50b0010 	str	r0, [fp, #-16] ; src
  int i;
  
  printf("display: ");
   10800:	e59f0064 	ldr	r0, [pc, #100]	; 1086c <display+0x7c>
   10804:	ebfffef9 	bl	103f0 <printf@plt>
  for (i = src->front; i < src->max_size; i++) {
   10808:	e51b3010 	ldr	r3, [fp, #-16] ; src
   1080c:	e5933004 	ldr	r3, [r3, #4]   ; src->front
   10810:	e50b3008 	str	r3, [fp, #-8]  ; fp-8=src->front
   10814:	ea00000b 	b	10848 <display+0x58>
    printf(" %d ", src->queue[i]);
   10818:	e51b3010 	ldr	r3, [fp, #-16] ; src
   1081c:	e5932000 	ldr	r2, [r3]       ; src->queue
   10820:	e51b3008 	ldr	r3, [fp, #-8]  ; src->front
   10824:	e1a03103 	lsl	r3, r3, #2     ; src->front<<=2
   10828:	e0823003 	add	r3, r2, r3     ; src->front=src->front<<2+src->queue
   1082c:	e5933000 	ldr	r3, [r3]       ; src->front = src->front<<2+src->queue
   10830:	e1a01003 	mov	r1, r3
   10834:	e59f0034 	ldr	r0, [pc, #52]	; 10870 <display+0x80>
   10838:	ebfffeec 	bl	103f0 <printf@plt>
void display(struct queue * src)
{
  int i;
  
  printf("display: ");
  for (i = src->front; i < src->max_size; i++) {
   1083c:	e51b3008 	ldr	r3, [fp, #-8] ; src->front
   10840:	e2833001 	add	r3, r3, #1    ; r3 = src->front+1
   10844:	e50b3008 	str	r3, [fp, #-8] ; src->front=src->front+1
   10848:	e51b3010 	ldr	r3, [fp, #-16] ; src
   1084c:	e593200c 	ldr	r2, [r3, #12]  ; src->max_size
   10850:	e51b3008 	ldr	r3, [fp, #-8]  ; src->front
   10854:	e1520003 	cmp	r2, r3
   10858:	caffffee 	bgt	10818 <display+0x28>
    printf(" %d ", src->queue[i]);
  }
  printf("\n\n");
   1085c:	e59f0010 	ldr	r0, [pc, #16]	; 10874 <display+0x84>
   10860:	ebfffee5 	bl	103fc <puts@plt>
}
   10864:	e24bd004 	sub	sp, fp, #4
   10868:	e8bd8800 	pop	{fp, pc}
   1086c:	00010f7c 	.word	0x00010f7c
   10870:	00010f88 	.word	0x00010f88
   10874:	00010f90 	.word	0x00010f90

00010878 <display_all>:

void display_all(struct queue * src)
{
   10878:	e92d4800 	push	{fp, lr}
   1087c:	e28db004 	add	fp, sp, #4
   10880:	e24dd010 	sub	sp, sp, #16
   10884:	e50b0010 	str	r0, [fp, #-16] ; src
  int i;
  
  printf("display all: ");
   10888:	e59f0060 	ldr	r0, [pc, #96]	; 108f0 <display_all+0x78>
   1088c:	ebfffed7 	bl	103f0 <printf@plt>
  for (i = 0; i < src->max_size; i++) {
   10890:	e3a03000 	mov	r3, #0
   10894:	e50b3008 	str	r3, [fp, #-8] ; fp-8 = i
   10898:	ea00000b 	b	108cc <display_all+0x54>
    printf(" %d ", src->queue[i]);
   1089c:	e51b3010 	ldr	r3, [fp, #-16] ; src
   108a0:	e5932000 	ldr	r2, [r3]       ; src->queue
   108a4:	e51b3008 	ldr	r3, [fp, #-8]  ; r3 = i
   108a8:	e1a03103 	lsl	r3, r3, #2     ; r3 = i = i << 2
   108ac:	e0823003 	add	r3, r2, r3     ; i = src->queue + i<<2
   108b0:	e5933000 	ldr	r3, [r3]       ; [i]
   108b4:	e1a01003 	mov	r1, r3
   108b8:	e59f0034 	ldr	r0, [pc, #52]	; 108f4 <display_all+0x7c>
   108bc:	ebfffecb 	bl	103f0 <printf@plt>
void display_all(struct queue * src)
{
  int i;
  
  printf("display all: ");
  for (i = 0; i < src->max_size; i++) {
   108c0:	e51b3008 	ldr	r3, [fp, #-8] ; i
   108c4:	e2833001 	add	r3, r3, #1    ; i + 1
   108c8:	e50b3008 	str	r3, [fp, #-8] ; i = i+1
   108cc:	e51b3010 	ldr	r3, [fp, #-16] ; src
   108d0:	e593200c 	ldr	r2, [r3, #12]  ; src->max_size
   108d4:	e51b3008 	ldr	r3, [fp, #-8]  ; i
   108d8:	e1520003 	cmp	r2, r3
   108dc:	caffffee 	bgt	1089c <display_all+0x24>
    printf(" %d ", src->queue[i]);
  }
  printf("\n\n");
   108e0:	e59f0010 	ldr	r0, [pc, #16]	; 108f8 <display_all+0x80>
   108e4:	ebfffec4 	bl	103fc <puts@plt>
}
   108e8:	e24bd004 	sub	sp, fp, #4
   108ec:	e8bd8800 	pop	{fp, pc}
   108f0:	00010f94 	.word	0x00010f94
   108f4:	00010f88 	.word	0x00010f88
   108f8:	00010f90 	.word	0x00010f90

000108fc <clean>:

void clean(struct queue * src)
{
   108fc:	e92d4800 	push	{fp, lr}
   10900:	e28db004 	add	fp, sp, #4
   10904:	e24dd008 	sub	sp, sp, #8
   10908:	e50b0008 	str	r0, [fp, #-8] ; src
  if (src->queue != NULL) {
   1090c:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10910:	e5933000 	ldr	r3, [r3]      ; src->queue
   10914:	e3530000 	cmp	r3, #0
   10918:	0a00000f 	beq	1095c <clean+0x60>
    free(src->queue);
   1091c:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10920:	e5933000 	ldr	r3, [r3]      ; src->queue
   10924:	e1a00003 	mov	r0, r3
   10928:	ebfffecb 	bl	1045c <free@plt>
    src->queue = NULL;
   1092c:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10930:	e3a02000 	mov	r2, #0
   10934:	e5832000 	str	r2, [r3] ; src->queue
    src->front = 0;
   10938:	e51b3008 	ldr	r3, [fp, #-8] ; src
   1093c:	e3a02000 	mov	r2, #0
   10940:	e5832004 	str	r2, [r3, #4] ; src->front
    src->rear  = 0;
   10944:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10948:	e3a02000 	mov	r2, #0
   1094c:	e5832008 	str	r2, [r3, #8] ; src->rear
    src->max_size = 0;
   10950:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10954:	e3a02000 	mov	r2, #0
   10958:	e583200c 	str	r2, [r3, #12] ; src->max_size
  }
}
   1095c:	e24bd004 	sub	sp, fp, #4
   10960:	e8bd8800 	pop	{fp, pc}

00010964 <main>:

int main()
{
   10964:	e92d4800 	push	{fp, lr}
   10968:	e28db004 	add	fp, sp, #4
   1096c:	e24dd018 	sub	sp, sp, #24
  struct queue queue;
  int max_size = 10;
   10970:	e3a0300a 	mov	r3, #10
   10974:	e50b3008 	str	r3, [fp, #-8]

  init(& queue, max_size);
   10978:	e24b3018 	sub	r3, fp, #24
   1097c:	e51b1008 	ldr	r1, [fp, #-8]
   10980:	e1a00003 	mov	r0, r3
   10984:	ebffff08 	bl	105ac <init>
  enqueue(& queue, 1);
   10988:	e24b3018 	sub	r3, fp, #24
   1098c:	e3a01001 	mov	r1, #1
   10990:	e1a00003 	mov	r0, r3
   10994:	ebffff4e 	bl	106d4 <enqueue>
  enqueue(& queue, 2);
   10998:	e24b3018 	sub	r3, fp, #24
   1099c:	e3a01002 	mov	r1, #2
   109a0:	e1a00003 	mov	r0, r3
   109a4:	ebffff4a 	bl	106d4 <enqueue>
  enqueue(& queue, 3);
   109a8:	e24b3018 	sub	r3, fp, #24
   109ac:	e3a01003 	mov	r1, #3
   109b0:	e1a00003 	mov	r0, r3
   109b4:	ebffff46 	bl	106d4 <enqueue>
  enqueue(& queue, 4);
   109b8:	e24b3018 	sub	r3, fp, #24
   109bc:	e3a01004 	mov	r1, #4
   109c0:	e1a00003 	mov	r0, r3
   109c4:	ebffff42 	bl	106d4 <enqueue>
  enqueue(& queue, 5);
   109c8:	e24b3018 	sub	r3, fp, #24
   109cc:	e3a01005 	mov	r1, #5
   109d0:	e1a00003 	mov	r0, r3
   109d4:	ebffff3e 	bl	106d4 <enqueue>
  enqueue(& queue, 6);
   109d8:	e24b3018 	sub	r3, fp, #24
   109dc:	e3a01006 	mov	r1, #6
   109e0:	e1a00003 	mov	r0, r3
   109e4:	ebffff3a 	bl	106d4 <enqueue>
  display(& queue);	// 1  2  3  4  5  6  0  0  0  0 
   109e8:	e24b3018 	sub	r3, fp, #24
   109ec:	e1a00003 	mov	r0, r3
   109f0:	ebffff7e 	bl	107f0 <display>

  dequeue(& queue);	// del 1
   109f4:	e24b3018 	sub	r3, fp, #24
   109f8:	e1a00003 	mov	r0, r3
   109fc:	ebffff58 	bl	10764 <dequeue>
  dequeue(& queue);	// del 2
   10a00:	e24b3018 	sub	r3, fp, #24
   10a04:	e1a00003 	mov	r0, r3
   10a08:	ebffff55 	bl	10764 <dequeue>
  display(& queue);	// 3  4  5  6  0  0  0  0
   10a0c:	e24b3018 	sub	r3, fp, #24
   10a10:	e1a00003 	mov	r0, r3
   10a14:	ebffff75 	bl	107f0 <display>

  enqueue(& queue, 11);
   10a18:	e24b3018 	sub	r3, fp, #24
   10a1c:	e3a0100b 	mov	r1, #11
   10a20:	e1a00003 	mov	r0, r3
   10a24:	ebffff2a 	bl	106d4 <enqueue>
  enqueue(& queue, 22);
   10a28:	e24b3018 	sub	r3, fp, #24
   10a2c:	e3a01016 	mov	r1, #22
   10a30:	e1a00003 	mov	r0, r3
   10a34:	ebffff26 	bl	106d4 <enqueue>
  enqueue(& queue, 33);
   10a38:	e24b3018 	sub	r3, fp, #24
   10a3c:	e3a01021 	mov	r1, #33	; 0x21
   10a40:	e1a00003 	mov	r0, r3
   10a44:	ebffff22 	bl	106d4 <enqueue>
  enqueue(& queue, 44);
   10a48:	e24b3018 	sub	r3, fp, #24
   10a4c:	e3a0102c 	mov	r1, #44	; 0x2c
   10a50:	e1a00003 	mov	r0, r3
   10a54:	ebffff1e 	bl	106d4 <enqueue>
  enqueue(& queue, 55);
   10a58:	e24b3018 	sub	r3, fp, #24
   10a5c:	e3a01037 	mov	r1, #55	; 0x37
   10a60:	e1a00003 	mov	r0, r3
   10a64:	ebffff1a 	bl	106d4 <enqueue>
  enqueue(& queue, 66);	// queue was full.
   10a68:	e24b3018 	sub	r3, fp, #24
   10a6c:	e3a01042 	mov	r1, #66	; 0x42
   10a70:	e1a00003 	mov	r0, r3
   10a74:	ebffff16 	bl	106d4 <enqueue>
  display(& queue);		// 3  4  5  6  11  22  33  44 
   10a78:	e24b3018 	sub	r3, fp, #24
   10a7c:	e1a00003 	mov	r0, r3
   10a80:	ebffff5a 	bl	107f0 <display>
  display_all(& queue);	// 55  -1  3  4  5  6  11  22  33  44
   10a84:	e24b3018 	sub	r3, fp, #24
   10a88:	e1a00003 	mov	r0, r3
   10a8c:	ebffff79 	bl	10878 <display_all>

  dequeue(& queue);		// del 3
   10a90:	e24b3018 	sub	r3, fp, #24
   10a94:	e1a00003 	mov	r0, r3
   10a98:	ebffff31 	bl	10764 <dequeue>
  dequeue(& queue);		// del 4
   10a9c:	e24b3018 	sub	r3, fp, #24
   10aa0:	e1a00003 	mov	r0, r3
   10aa4:	ebffff2e 	bl	10764 <dequeue>
  display(& queue);		// 5  6  11  22  33  44
   10aa8:	e24b3018 	sub	r3, fp, #24
   10aac:	e1a00003 	mov	r0, r3
   10ab0:	ebffff4e 	bl	107f0 <display>
  display_all(& queue);	// 55  -1  -1  -1  5  6  11  22  33  44
   10ab4:	e24b3018 	sub	r3, fp, #24
   10ab8:	e1a00003 	mov	r0, r3
   10abc:	ebffff6d 	bl	10878 <display_all>

  dequeue(& queue);		// del 5
   10ac0:	e24b3018 	sub	r3, fp, #24
   10ac4:	e1a00003 	mov	r0, r3
   10ac8:	ebffff25 	bl	10764 <dequeue>
  dequeue(& queue);		// del 6
   10acc:	e24b3018 	sub	r3, fp, #24
   10ad0:	e1a00003 	mov	r0, r3
   10ad4:	ebffff22 	bl	10764 <dequeue>
  dequeue(& queue);		// del 11
   10ad8:	e24b3018 	sub	r3, fp, #24
   10adc:	e1a00003 	mov	r0, r3
   10ae0:	ebffff1f 	bl	10764 <dequeue>
  dequeue(& queue);		// del 22
   10ae4:	e24b3018 	sub	r3, fp, #24
   10ae8:	e1a00003 	mov	r0, r3
   10aec:	ebffff1c 	bl	10764 <dequeue>
  dequeue(& queue);		// del 33
   10af0:	e24b3018 	sub	r3, fp, #24
   10af4:	e1a00003 	mov	r0, r3
   10af8:	ebffff19 	bl	10764 <dequeue>
  dequeue(& queue);		// del 44
   10afc:	e24b3018 	sub	r3, fp, #24
   10b00:	e1a00003 	mov	r0, r3
   10b04:	ebffff16 	bl	10764 <dequeue>
  display(& queue);		// 55  -1  -1  -1  -1  -1  -1  -1  -1  -1
   10b08:	e24b3018 	sub	r3, fp, #24
   10b0c:	e1a00003 	mov	r0, r3
   10b10:	ebffff36 	bl	107f0 <display>
  display_all(& queue);	// 55  -1  -1  -1  -1  -1  -1  -1  -1  -1 
   10b14:	e24b3018 	sub	r3, fp, #24
   10b18:	e1a00003 	mov	r0, r3
   10b1c:	ebffff55 	bl	10878 <display_all>

  enqueue(& queue, 1);
   10b20:	e24b3018 	sub	r3, fp, #24
   10b24:	e3a01001 	mov	r1, #1
   10b28:	e1a00003 	mov	r0, r3
   10b2c:	ebfffee8 	bl	106d4 <enqueue>
  enqueue(& queue, 2);
   10b30:	e24b3018 	sub	r3, fp, #24
   10b34:	e3a01002 	mov	r1, #2
   10b38:	e1a00003 	mov	r0, r3
   10b3c:	ebfffee4 	bl	106d4 <enqueue>
  enqueue(& queue, 3);
   10b40:	e24b3018 	sub	r3, fp, #24
   10b44:	e3a01003 	mov	r1, #3
   10b48:	e1a00003 	mov	r0, r3
   10b4c:	ebfffee0 	bl	106d4 <enqueue>
  enqueue(& queue, 4);
   10b50:	e24b3018 	sub	r3, fp, #24
   10b54:	e3a01004 	mov	r1, #4
   10b58:	e1a00003 	mov	r0, r3
   10b5c:	ebfffedc 	bl	106d4 <enqueue>
  enqueue(& queue, 5);
   10b60:	e24b3018 	sub	r3, fp, #24
   10b64:	e3a01005 	mov	r1, #5
   10b68:	e1a00003 	mov	r0, r3
   10b6c:	ebfffed8 	bl	106d4 <enqueue>
  enqueue(& queue, 6);
   10b70:	e24b3018 	sub	r3, fp, #24
   10b74:	e3a01006 	mov	r1, #6
   10b78:	e1a00003 	mov	r0, r3
   10b7c:	ebfffed4 	bl	106d4 <enqueue>
  display(& queue);		// 55  1  2  3  4  5  6  -1  -1  -1
   10b80:	e24b3018 	sub	r3, fp, #24
   10b84:	e1a00003 	mov	r0, r3
   10b88:	ebffff18 	bl	107f0 <display>
  display_all(& queue);	// 55  1  2  3  4  5  6  -1  -1  -1 
   10b8c:	e24b3018 	sub	r3, fp, #24
   10b90:	e1a00003 	mov	r0, r3
   10b94:	ebffff37 	bl	10878 <display_all>


  enqueue(& queue, 11);
   10b98:	e24b3018 	sub	r3, fp, #24
   10b9c:	e3a0100b 	mov	r1, #11
   10ba0:	e1a00003 	mov	r0, r3
   10ba4:	ebfffeca 	bl	106d4 <enqueue>
  enqueue(& queue, 22);
   10ba8:	e24b3018 	sub	r3, fp, #24
   10bac:	e3a01016 	mov	r1, #22
   10bb0:	e1a00003 	mov	r0, r3
   10bb4:	ebfffec6 	bl	106d4 <enqueue>
  enqueue(& queue, 33);	// queue was full.
   10bb8:	e24b3018 	sub	r3, fp, #24
   10bbc:	e3a01021 	mov	r1, #33	; 0x21
   10bc0:	e1a00003 	mov	r0, r3
   10bc4:	ebfffec2 	bl	106d4 <enqueue>
  enqueue(& queue, 44);	// queue was full.
   10bc8:	e24b3018 	sub	r3, fp, #24
   10bcc:	e3a0102c 	mov	r1, #44	; 0x2c
   10bd0:	e1a00003 	mov	r0, r3
   10bd4:	ebfffebe 	bl	106d4 <enqueue>
  enqueue(& queue, 55);	// queue was full.
   10bd8:	e24b3018 	sub	r3, fp, #24
   10bdc:	e3a01037 	mov	r1, #55	; 0x37
   10be0:	e1a00003 	mov	r0, r3
   10be4:	ebfffeba 	bl	106d4 <enqueue>
  enqueue(& queue, 66);	// queue was full.
   10be8:	e24b3018 	sub	r3, fp, #24
   10bec:	e3a01042 	mov	r1, #66	; 0x42
   10bf0:	e1a00003 	mov	r0, r3
   10bf4:	ebfffeb6 	bl	106d4 <enqueue>
  display(& queue);		// 55  1  2  3  4  5  6  11  22  -1 
   10bf8:	e24b3018 	sub	r3, fp, #24
   10bfc:	e1a00003 	mov	r0, r3
   10c00:	ebfffefa 	bl	107f0 <display>
  display_all(& queue);	// 55  1  2  3  4  5  6  11  22  -1 
   10c04:	e24b3018 	sub	r3, fp, #24
   10c08:	e1a00003 	mov	r0, r3
   10c0c:	ebffff19 	bl	10878 <display_all>

  dequeue(& queue);		// del 55
   10c10:	e24b3018 	sub	r3, fp, #24
   10c14:	e1a00003 	mov	r0, r3
   10c18:	ebfffed1 	bl	10764 <dequeue>
  dequeue(& queue);		// del 1
   10c1c:	e24b3018 	sub	r3, fp, #24
   10c20:	e1a00003 	mov	r0, r3
   10c24:	ebfffece 	bl	10764 <dequeue>
  display(& queue);		// 2  3  4  5  6  11  22  -1
   10c28:	e24b3018 	sub	r3, fp, #24
   10c2c:	e1a00003 	mov	r0, r3
   10c30:	ebfffeee 	bl	107f0 <display>
  display_all(& queue);	// -1  -1  2  3  4  5  6  11  22  -1
   10c34:	e24b3018 	sub	r3, fp, #24
   10c38:	e1a00003 	mov	r0, r3
   10c3c:	ebffff0d 	bl	10878 <display_all>

  enqueue(& queue, 83);
   10c40:	e24b3018 	sub	r3, fp, #24
   10c44:	e3a01053 	mov	r1, #83	; 0x53
   10c48:	e1a00003 	mov	r0, r3
   10c4c:	ebfffea0 	bl	106d4 <enqueue>
  enqueue(& queue, 84);
   10c50:	e24b3018 	sub	r3, fp, #24
   10c54:	e3a01054 	mov	r1, #84	; 0x54
   10c58:	e1a00003 	mov	r0, r3
   10c5c:	ebfffe9c 	bl	106d4 <enqueue>
  enqueue(& queue, 85);	// queue was full.
   10c60:	e24b3018 	sub	r3, fp, #24
   10c64:	e3a01055 	mov	r1, #85	; 0x55
   10c68:	e1a00003 	mov	r0, r3
   10c6c:	ebfffe98 	bl	106d4 <enqueue>
  enqueue(& queue, 86);	// queue was full.
   10c70:	e24b3018 	sub	r3, fp, #24
   10c74:	e3a01056 	mov	r1, #86	; 0x56
   10c78:	e1a00003 	mov	r0, r3
   10c7c:	ebfffe94 	bl	106d4 <enqueue>
  display(& queue);		// 2  3  4  5  6  11  22  83 
   10c80:	e24b3018 	sub	r3, fp, #24
   10c84:	e1a00003 	mov	r0, r3
   10c88:	ebfffed8 	bl	107f0 <display>
  display_all(& queue);	// 84  -1  2  3  4  5  6  11  22  83
   10c8c:	e24b3018 	sub	r3, fp, #24
   10c90:	e1a00003 	mov	r0, r3
   10c94:	ebfffef7 	bl	10878 <display_all>

  enqueue(& queue, 93);	// queue was full.
   10c98:	e24b3018 	sub	r3, fp, #24
   10c9c:	e3a0105d 	mov	r1, #93	; 0x5d
   10ca0:	e1a00003 	mov	r0, r3
   10ca4:	ebfffe8a 	bl	106d4 <enqueue>
  enqueue(& queue, 96);	// queue was full.
   10ca8:	e24b3018 	sub	r3, fp, #24
   10cac:	e3a01060 	mov	r1, #96	; 0x60
   10cb0:	e1a00003 	mov	r0, r3
   10cb4:	ebfffe86 	bl	106d4 <enqueue>
  display(& queue);		// 2  3  4  5  6  11  22  83
   10cb8:	e24b3018 	sub	r3, fp, #24
   10cbc:	e1a00003 	mov	r0, r3
   10cc0:	ebfffeca 	bl	107f0 <display>
  display_all(& queue);	// 84  -1  2  3  4  5  6  11  22  83
   10cc4:	e24b3018 	sub	r3, fp, #24
   10cc8:	e1a00003 	mov	r0, r3
   10ccc:	ebfffee9 	bl	10878 <display_all>

  clean(& queue);
   10cd0:	e24b3018 	sub	r3, fp, #24
   10cd4:	e1a00003 	mov	r0, r3
   10cd8:	ebffff07 	bl	108fc <clean>
}
   10cdc:	e1a00003 	mov	r0, r3
   10ce0:	e24bd004 	sub	sp, fp, #4
   10ce4:	e8bd8800 	pop	{fp, pc}

00010ce8 <__aeabi_idiv>:
   10ce8:	e3510000 	cmp	r1, #0
   10cec:	0a000081 	beq	10ef8 <.divsi3_skip_div0_test+0x208>

00010cf0 <.divsi3_skip_div0_test>:
   10cf0:	e020c001 	eor	ip, r0, r1
   10cf4:	42611000 	rsbmi	r1, r1, #0
   10cf8:	e2512001 	subs	r2, r1, #1
   10cfc:	0a000070 	beq	10ec4 <.divsi3_skip_div0_test+0x1d4>
   10d00:	e1b03000 	movs	r3, r0
   10d04:	42603000 	rsbmi	r3, r0, #0
   10d08:	e1530001 	cmp	r3, r1
   10d0c:	9a00006f 	bls	10ed0 <.divsi3_skip_div0_test+0x1e0>
   10d10:	e1110002 	tst	r1, r2
   10d14:	0a000071 	beq	10ee0 <.divsi3_skip_div0_test+0x1f0>
   10d18:	e16f2f13 	clz	r2, r3
   10d1c:	e16f0f11 	clz	r0, r1
   10d20:	e0402002 	sub	r2, r0, r2
   10d24:	e272201f 	rsbs	r2, r2, #31
   10d28:	10822082 	addne	r2, r2, r2, lsl #1
   10d2c:	e3a00000 	mov	r0, #0
   10d30:	108ff102 	addne	pc, pc, r2, lsl #2
   10d34:	e1a00000 	nop			; (mov r0, r0)
   10d38:	e1530f81 	cmp	r3, r1, lsl #31
   10d3c:	e0a00000 	adc	r0, r0, r0
   10d40:	20433f81 	subcs	r3, r3, r1, lsl #31
   10d44:	e1530f01 	cmp	r3, r1, lsl #30
   10d48:	e0a00000 	adc	r0, r0, r0
   10d4c:	20433f01 	subcs	r3, r3, r1, lsl #30
   10d50:	e1530e81 	cmp	r3, r1, lsl #29
   10d54:	e0a00000 	adc	r0, r0, r0
   10d58:	20433e81 	subcs	r3, r3, r1, lsl #29
   10d5c:	e1530e01 	cmp	r3, r1, lsl #28
   10d60:	e0a00000 	adc	r0, r0, r0
   10d64:	20433e01 	subcs	r3, r3, r1, lsl #28
   10d68:	e1530d81 	cmp	r3, r1, lsl #27
   10d6c:	e0a00000 	adc	r0, r0, r0
   10d70:	20433d81 	subcs	r3, r3, r1, lsl #27
   10d74:	e1530d01 	cmp	r3, r1, lsl #26
   10d78:	e0a00000 	adc	r0, r0, r0
   10d7c:	20433d01 	subcs	r3, r3, r1, lsl #26
   10d80:	e1530c81 	cmp	r3, r1, lsl #25
   10d84:	e0a00000 	adc	r0, r0, r0
   10d88:	20433c81 	subcs	r3, r3, r1, lsl #25
   10d8c:	e1530c01 	cmp	r3, r1, lsl #24
   10d90:	e0a00000 	adc	r0, r0, r0
   10d94:	20433c01 	subcs	r3, r3, r1, lsl #24
   10d98:	e1530b81 	cmp	r3, r1, lsl #23
   10d9c:	e0a00000 	adc	r0, r0, r0
   10da0:	20433b81 	subcs	r3, r3, r1, lsl #23
   10da4:	e1530b01 	cmp	r3, r1, lsl #22
   10da8:	e0a00000 	adc	r0, r0, r0
   10dac:	20433b01 	subcs	r3, r3, r1, lsl #22
   10db0:	e1530a81 	cmp	r3, r1, lsl #21
   10db4:	e0a00000 	adc	r0, r0, r0
   10db8:	20433a81 	subcs	r3, r3, r1, lsl #21
   10dbc:	e1530a01 	cmp	r3, r1, lsl #20
   10dc0:	e0a00000 	adc	r0, r0, r0
   10dc4:	20433a01 	subcs	r3, r3, r1, lsl #20
   10dc8:	e1530981 	cmp	r3, r1, lsl #19
   10dcc:	e0a00000 	adc	r0, r0, r0
   10dd0:	20433981 	subcs	r3, r3, r1, lsl #19
   10dd4:	e1530901 	cmp	r3, r1, lsl #18
   10dd8:	e0a00000 	adc	r0, r0, r0
   10ddc:	20433901 	subcs	r3, r3, r1, lsl #18
   10de0:	e1530881 	cmp	r3, r1, lsl #17
   10de4:	e0a00000 	adc	r0, r0, r0
   10de8:	20433881 	subcs	r3, r3, r1, lsl #17
   10dec:	e1530801 	cmp	r3, r1, lsl #16
   10df0:	e0a00000 	adc	r0, r0, r0
   10df4:	20433801 	subcs	r3, r3, r1, lsl #16
   10df8:	e1530781 	cmp	r3, r1, lsl #15
   10dfc:	e0a00000 	adc	r0, r0, r0
   10e00:	20433781 	subcs	r3, r3, r1, lsl #15
   10e04:	e1530701 	cmp	r3, r1, lsl #14
   10e08:	e0a00000 	adc	r0, r0, r0
   10e0c:	20433701 	subcs	r3, r3, r1, lsl #14
   10e10:	e1530681 	cmp	r3, r1, lsl #13
   10e14:	e0a00000 	adc	r0, r0, r0
   10e18:	20433681 	subcs	r3, r3, r1, lsl #13
   10e1c:	e1530601 	cmp	r3, r1, lsl #12
   10e20:	e0a00000 	adc	r0, r0, r0
   10e24:	20433601 	subcs	r3, r3, r1, lsl #12
   10e28:	e1530581 	cmp	r3, r1, lsl #11
   10e2c:	e0a00000 	adc	r0, r0, r0
   10e30:	20433581 	subcs	r3, r3, r1, lsl #11
   10e34:	e1530501 	cmp	r3, r1, lsl #10
   10e38:	e0a00000 	adc	r0, r0, r0
   10e3c:	20433501 	subcs	r3, r3, r1, lsl #10
   10e40:	e1530481 	cmp	r3, r1, lsl #9
   10e44:	e0a00000 	adc	r0, r0, r0
   10e48:	20433481 	subcs	r3, r3, r1, lsl #9
   10e4c:	e1530401 	cmp	r3, r1, lsl #8
   10e50:	e0a00000 	adc	r0, r0, r0
   10e54:	20433401 	subcs	r3, r3, r1, lsl #8
   10e58:	e1530381 	cmp	r3, r1, lsl #7
   10e5c:	e0a00000 	adc	r0, r0, r0
   10e60:	20433381 	subcs	r3, r3, r1, lsl #7
   10e64:	e1530301 	cmp	r3, r1, lsl #6
   10e68:	e0a00000 	adc	r0, r0, r0
   10e6c:	20433301 	subcs	r3, r3, r1, lsl #6
   10e70:	e1530281 	cmp	r3, r1, lsl #5
   10e74:	e0a00000 	adc	r0, r0, r0
   10e78:	20433281 	subcs	r3, r3, r1, lsl #5
   10e7c:	e1530201 	cmp	r3, r1, lsl #4
   10e80:	e0a00000 	adc	r0, r0, r0
   10e84:	20433201 	subcs	r3, r3, r1, lsl #4
   10e88:	e1530181 	cmp	r3, r1, lsl #3
   10e8c:	e0a00000 	adc	r0, r0, r0
   10e90:	20433181 	subcs	r3, r3, r1, lsl #3
   10e94:	e1530101 	cmp	r3, r1, lsl #2
   10e98:	e0a00000 	adc	r0, r0, r0
   10e9c:	20433101 	subcs	r3, r3, r1, lsl #2
   10ea0:	e1530081 	cmp	r3, r1, lsl #1
   10ea4:	e0a00000 	adc	r0, r0, r0
   10ea8:	20433081 	subcs	r3, r3, r1, lsl #1
   10eac:	e1530001 	cmp	r3, r1
   10eb0:	e0a00000 	adc	r0, r0, r0
   10eb4:	20433001 	subcs	r3, r3, r1
   10eb8:	e35c0000 	cmp	ip, #0
   10ebc:	42600000 	rsbmi	r0, r0, #0
   10ec0:	e12fff1e 	bx	lr
   10ec4:	e13c0000 	teq	ip, r0
   10ec8:	42600000 	rsbmi	r0, r0, #0
   10ecc:	e12fff1e 	bx	lr
   10ed0:	33a00000 	movcc	r0, #0
   10ed4:	01a00fcc 	asreq	r0, ip, #31
   10ed8:	03800001 	orreq	r0, r0, #1
   10edc:	e12fff1e 	bx	lr
   10ee0:	e16f2f11 	clz	r2, r1
   10ee4:	e262201f 	rsb	r2, r2, #31
   10ee8:	e35c0000 	cmp	ip, #0
   10eec:	e1a00233 	lsr	r0, r3, r2
   10ef0:	42600000 	rsbmi	r0, r0, #0
   10ef4:	e12fff1e 	bx	lr
   10ef8:	e3500000 	cmp	r0, #0
   10efc:	c3e00102 	mvngt	r0, #-2147483648	; 0x80000000
   10f00:	b3a00102 	movlt	r0, #-2147483648	; 0x80000000
   10f04:	ea000007 	b	10f28 <__aeabi_idiv0>

00010f08 <__aeabi_idivmod>:
   10f08:	e3510000 	cmp	r1, #0
   10f0c:	0afffff9 	beq	10ef8 <.divsi3_skip_div0_test+0x208>
   10f10:	e92d4003 	push	{r0, r1, lr}
   10f14:	ebffff75 	bl	10cf0 <.divsi3_skip_div0_test>
   10f18:	e8bd4006 	pop	{r1, r2, lr}
   10f1c:	e0030092 	mul	r3, r2, r0
   10f20:	e0411003 	sub	r1, r1, r3
   10f24:	e12fff1e 	bx	lr

00010f28 <__aeabi_idiv0>:
   10f28:	e92d4002 	push	{r1, lr}
   10f2c:	e3a00008 	mov	r0, #8
   10f30:	ebfffd46 	bl	10450 <raise@plt>
   10f34:	e8bd8002 	pop	{r1, pc}

Disassembly of section .fini:

00010f38 <_fini>:
   10f38:	e1a0c00d 	mov	ip, sp
   10f3c:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   10f40:	e24cb004 	sub	fp, ip, #4
   10f44:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}
